/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "视口元素.h"

#include <场景/intern/S_Scene.h>


static S_线逐顶点有色线段材质* g_网格线材质 = nullptr;


static S_RGBA8UI R = S_RGBA8UI{ 240, 70, 90, 255 };
static S_RGBA8UI G = S_RGBA8UI{ 140 ,240, 60, 255 };
static S_RGBA8UI B = S_RGBA8UI{ 60, 140, 240, 255 };

static float32 R亮度 = dot(1 - vec3{ 0.2125, 0.7154, 0.0721 }, f_RGB(R)) * 2.2;
static float32 G亮度 = dot(1 - vec3{ 0.2125, 0.7154, 0.0721 }, f_RGB(G)) * 2.2;
static float32 B亮度 = dot(1 - vec3{ 0.2125, 0.7154, 0.0721 }, f_RGB(B)) * 2.2;


//void f_初始化3D视口基准网格线(S_设备环境& ctx) {
//	f_node_初始化单虚拟体网格(ctx);
//	S_框架::g_基准网格线 = f_ob_创建网格物体(ctx);
//	S_框架::g_基准网格线->m_Name = u"场景视口网格";
//	S_框架::g_基准网格线->m_视口显示模式 = 1<<0 | 1<<1 | 1<<2;
//	S_框架::g_基准网格线->m_视口显示模式 |= S_框架::g_基准网格线->m_视口显示模式<<16;
//
//
//	S_Mesh* 基线 = f_surface_创建网格对象(nullptr, ctx, false, E_网格数据枚举::e_Mesh_Vulkan);
//	S_Mesh* 主线 = f_surface_创建网格对象(nullptr, ctx, false, E_网格数据枚举::e_Mesh_Vulkan);
//	S_Mesh* 辅线 = f_surface_创建网格对象(nullptr, ctx, false, E_网格数据枚举::e_Mesh_Vulkan);
//	f_ob_set数据槽数量(S_框架::g_基准网格线, 3);
//
//	f_ob_set数据(S_框架::g_基准网格线, 基线, 0);
//	f_ob_set数据(S_框架::g_基准网格线, 主线, 1);
//	f_ob_set数据(S_框架::g_基准网格线, 辅线, 2);
//
//	g_网格线材质 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
//	f_ob_set材质(S_框架::g_基准网格线, g_网格线材质, 0);
//	f_ob_set材质(S_框架::g_基准网格线, g_网格线材质, 1);
//	f_ob_set材质(S_框架::g_基准网格线, g_网格线材质, 2);
//
//	f_mesh_gen网格元素绘制属性(基线, 1);
//	f_mesh_gen网格元素绘制属性(主线, 1);
//	f_mesh_gen网格元素绘制属性(辅线, 1);
//	S_Vert_MeshDrawProp Prop{};
//	f_mesh_set绘制内存属性(基线, Prop);
//	f_mesh_set绘制内存属性(主线, Prop);
//	f_mesh_set绘制内存属性(辅线, Prop);
//
//	auto 网格属性 = f_init_MeshTranform();
//	网格属性.m_DepthScale = 1;
//	f_mesh_set网格元素绘制属性(基线, 网格属性);
//	f_mesh_set网格元素绘制属性(主线, 网格属性);
//	f_mesh_set网格元素绘制属性(辅线, 网格属性);
//	
//
//
//	int32 num = 60;
//	float32 长度 = 600;
//
//	std::vector<S_VC> 顶点;
//	顶点.reserve(4);
//	顶点.push_back({ { -长度, 0.0f, 0.0f }, f_PackData4X8({ 255,100,100,200 }) });
//	顶点.push_back({ { 长度, 0.0f, 0.0f }, f_PackData4X8({ 255,100,100,200 }) });
//	顶点.push_back({ { 0.0f, 0.0f, -长度 }, f_PackData4X8({ 100,100,255,200 }) });
//	顶点.push_back({ { 0.0f, 0.0f, 长度 }, f_PackData4X8({ 100,100,255,200 }) });
//	f_mesh_fill顶点数据(基线, 顶点);
//	基线->m_线宽 = 1.5;
//
//
//	顶点.clear();
//	顶点.reserve(num * 4 * 2);
//	for (uint32 i = 1; i < num; ++i) {
//		vec3 vx = {};
//
//		vx.x = 长度;
//		vx.z = 10.0f * i;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_主线辅线) });
//		vx.x = -长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_主线辅线) });
//
//		vx.x = 长度;
//		vx.z = -10.0f * float32(i);
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_主线辅线) });
//		vx.x = -长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_主线辅线) });
//
//
//
//		vx.x = 10.0f * i;
//		vx.z = 长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_主线辅线) });
//		vx.z = -长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_主线辅线) });
//
//		vx.x = -10.0f * i;
//		vx.z = 长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_主线辅线) });
//		vx.z = -长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_主线辅线) });
//	}
//	
//	f_mesh_fill顶点数据(主线, 顶点);
//	主线->m_线宽 = 1.5;
//
//	
//	num *= 10;
//	顶点.clear();
//	顶点.reserve(num * 4 * 2);
//	for (uint32 i = 1; i < num; ++i) {
//		vec3 vx = {};
//
//		vx.x = 长度;
//		vx.z = i;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_网格辅线) });
//		vx.x = -长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_网格辅线) });
//
//		vx.x = 长度;
//		vx.z = -float32(i);
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_网格辅线) });
//		vx.x = -长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_网格辅线) });
//
//
//
//		vx.x = i;
//		vx.z = 长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_网格辅线) });
//		vx.z = -长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_网格辅线) });
//
//		vx.x = -float32(i);
//		vx.z = 长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_网格辅线) });
//		vx.z = -长度;
//		顶点.push_back({ vx, f_PackData4X8(S_节点UI主题::uic_网格辅线) });
//	}
//	f_mesh_fill顶点数据(辅线, 顶点);
//	辅线->m_线宽 = 0.5;
//	
//
//	//S_节点数据::m_包围盒物体 = f_node_创建包围盒虚拟体(ctx);
//	//S_物体::g_包围盒物体 = S_节点数据::m_包围盒物体;
//
//
//	f_NodeCtx_get默认场景()->f_add物体(S_框架::g_基准网格线);
//}

void f_初始化3D视口全局坐标小组件(S_设备环境& ctx) {
	S_Mesh* 线 = f_surface_创建网格对象(0, ctx, false, E_网格数据枚举::e_Mesh_Vulkan);
	f_mesh_gen网格元素绘制属性(线, 1);

	S_Mesh* 点 = f_surface_创建网格对象(0, ctx, false, E_网格数据枚举::e_Mesh_Vulkan);
	f_mesh_gen网格元素绘制属性(点, 1);

	S_Mesh* 点边 = f_surface_创建网格对象(0, ctx, false, E_网格数据枚举::e_Mesh_Vulkan);
	f_mesh_gen网格元素绘制属性(点边, 1);


	std::vector<S_VNT1> 顶点;

	float32 r = 0.5;
	顶点.push_back({ {0, 0, 0}, f_RGB(R), {} });
	顶点.push_back({ {1, 0, 0}, f_RGB(R), {} });

	顶点.push_back({ {0, 0, 0}, f_RGB(G), {} });
	顶点.push_back({ {0, 1, 0}, f_RGB(G), {} });

	顶点.push_back({ {0, 0, 0}, f_RGB(B), {} });
	顶点.push_back({ {0, 0, 1}, f_RGB(B), {} });

	//顶点.push_back({ {0, 0, 0}, {1,1,1}, {} });
	//顶点.push_back({ {-1, 0, 0}, {1,1,1}, {} });


	std::vector<uint32> 索引;
	索引 = { 0,1, 0xffffffff, 0,2, 0xffffffff, 0,3 };
	索引 = { 0,1,  2,3, 4,5 };


	f_mesh_fill顶点数据(线, 顶点);
	f_mesh_set绘制内存属性(线, {});
	f_mesh_set网格元素绘制属性(线, f_init_MeshTranform());
	线->m_片源着色模式 = DEF_DrawType_Normal_To_Col;
	

	
	float32 亮度 = 0;
	顶点.clear();
	顶点.push_back({ {1, 0, 0}, f_RGB(R), {float32((*S_全局缓存::g_默认图标)["X"]), 亮度}});
	顶点.push_back({ {0, 1, 0}, f_RGB(G), {float32((*S_全局缓存::g_默认图标)["Y"]), 亮度} });
	顶点.push_back({ {0, 0, 1}, f_RGB(B), {float32((*S_全局缓存::g_默认图标)["Z"]), 亮度} });
	顶点.push_back({ {-1, 0, 0}, f_RGB(R) * 0.5f, {float32((*S_全局缓存::g_默认图标)[""]), 亮度} });
	顶点.push_back({ {0, -1, 0}, f_RGB(G) * 0.5f, {float32((*S_全局缓存::g_默认图标)[""]), 亮度} });
	顶点.push_back({ {0, 0, -1}, f_RGB(B) * 0.5f, {float32((*S_全局缓存::g_默认图标)[""]), 亮度} });

	//索引 = { 0,1, 0xffffffff, 0,2, 0xffffffff, 0,3 };
	f_mesh_fill顶点数据(点, 顶点);
	f_mesh_set绘制内存属性(点, {});

	auto 绘制属性 = f_init_MeshTranform();
	//绘制属性.m_TransformMode = DEF_DrawType_ICO_ColorInvert;
	绘制属性.m_ZScale = 30;
	绘制属性.m_Scale = 0.8;
	绘制属性.m_DepthScale = -0.0005;
	绘制属性.m_TransformMode = DEF_DrawType_ICO_CircularBackground;
	f_mesh_set网格元素绘制属性(点, 绘制属性);



	顶点.clear();
	顶点.push_back({ {1, 0, 0}, f_RGB(R) * R亮度, {0, 亮度} });
	顶点.push_back({ {0, 1, 0}, f_RGB(G) * G亮度, {0, 亮度} });
	顶点.push_back({ {0, 0, 1}, f_RGB(B) * B亮度, {0, 亮度} });
	顶点.push_back({ {-1, 0, 0}, f_RGB(R) * R亮度 * 0.8, {0, 亮度} });
	顶点.push_back({ {0, -1, 0}, f_RGB(G) * G亮度 * 0.8, {0, 亮度} });
	顶点.push_back({ {0, 0, -1}, f_RGB(B) * B亮度 * 0.8, {0, 亮度} });
	f_mesh_fill顶点数据(点边, 顶点);
	f_mesh_set绘制内存属性(点边, {});
	绘制属性.m_Scale = 1.0;
	绘制属性.m_TransformMode = DEF_DrawType_Col_CircularBackground;
	f_mesh_set网格元素绘制属性(点边, 绘制属性);



	S_框架::g_场景方向轴 = f_ob_创建(ctx, E_物体类型::t_网格物体);
	f_ob_set数据槽数量(S_框架::g_场景方向轴, 3);
	f_ob_set数据(S_框架::g_场景方向轴, 线, 0);
	f_ob_set数据(S_框架::g_场景方向轴, 点边, 1);
	f_ob_set数据(S_框架::g_场景方向轴, 点, 2);

	f_ob_set材质(S_框架::g_场景方向轴, f_NodeCtx_get索引绘制_颜色线材质(true), 0);
	f_ob_set材质(S_框架::g_场景方向轴, f_NodeCtx_get图标材质(), 1);
	f_ob_set材质(S_框架::g_场景方向轴, f_NodeCtx_get图标材质(), 2);
	

	f_ob_set线宽(S_框架::g_场景方向轴, 2.0, 0);
	S_框架::g_场景方向轴->m_视口显示模式 = 1 << 0 | 1 << 1 | 1 << 2;
	S_框架::g_场景方向轴->m_视口显示模式 |= S_框架::g_场景方向轴->m_视口显示模式 << 16;

	//f_NodeCtx_get图标材质()->m_图标纹理 = S_Engine::g_默认图标->m_Tex;
	

	S_框架::g_小组件场景->f_add物体(S_框架::g_场景方向轴);
}





static S_Mesh* g手柄线 = nullptr;
static S_Mesh* g手柄面 = nullptr;
static S_物体* G外接圆线 = nullptr;







